home *** CD-ROM | disk | FTP | other *** search
/ Collection of Internet / Collection of Internet.iso / msdos / lynx / source / doslynx / src / htfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-25  |  29.2 KB  |  1,138 lines
  1. /*            File Access                HTFile.c
  2. **            ===========
  3. **
  4. **    This is unix-specific code in general, with some VMS bits.
  5. **    These are routines for file access used by browsers.
  6. **
  7. ** History:
  8. **       Feb 91    Written Tim Berners-Lee CERN/CN
  9. **       Apr 91    vms-vms access included using DECnet syntax
  10. **    26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
  11. **            Fixed access bug for relative names on VMS.
  12. **       Sep 93 (MD)  Access to VMS files allows sharing.
  13. **    15 Nov 93 (MD)    Moved HTVMSname to HTVMSUTILS.C
  14. **
  15. ** Bugs:
  16. **    FTP: Cannot access VMS files from a unix machine.
  17. **      How can we know that the
  18. **    target machine runs VMS?
  19. */
  20.  
  21. #include"capalloc.h"
  22. #include "HTFile.h"        /* Implemented here */
  23. #include"capstdio.h"
  24.  
  25.  
  26. #define INFINITY 512        /* file name length @@ FIXME */
  27. #define MULTI_SUFFIX ".multi"   /* Extension for scanning formats */
  28.  
  29. #include "HTUtils.h"
  30.  
  31. #ifdef VMS
  32. #include "HTVMSUtils.h"
  33. #endif /* VMS */
  34.  
  35. #include "HTParse.h"
  36. #include "tcp.h"
  37. #include "HTTCP.h"
  38. #ifndef DECNET
  39. #include "HTFTP.h"
  40. #endif
  41. #include "HTAnchor.h"
  42. #include "HTAtom.h"
  43. #include "HTWriter.h"
  44. #include "HTFWriter.h"
  45. #include "HTInit.h"
  46. #include "HTBTree.h"
  47.  
  48. typedef struct _HTSuffix {
  49.     char *        suffix;
  50.     HTAtom *    rep;
  51.     HTAtom *    encoding;
  52.     float        quality;
  53. } HTSuffix;
  54.  
  55.  
  56. #ifdef USE_DIRENT        /* Set this for Sys V systems */
  57. #define STRUCT_DIRENT struct dirent
  58. #else
  59. #define STRUCT_DIRENT struct direct
  60. #endif
  61.  
  62. #include "HTML.h"        /* For directory object building */
  63.  
  64. #define PUTC(c) (*target->isa->put_character)(target, c)
  65. #define PUTS(s) (*target->isa->put_string)(target, s)
  66. #define START(e) (*target->isa->start_element)(target, e, 0, 0)
  67. #define END(e) (*target->isa->end_element)(target, e)
  68. #define FREE_TARGET (*target->isa->free)(target)
  69. struct _HTStructured {
  70.     CONST HTStructuredClass *    isa;
  71.     /* ... */
  72. };
  73.  
  74.  
  75. /*                   Controlling globals
  76. **
  77. */
  78.  
  79. PUBLIC int HTDirAccess = HT_DIR_OK;
  80. PUBLIC int HTDirReadme = HT_DIR_README_TOP;
  81.  
  82. PRIVATE char *HTMountRoot = "/Net/";        /* Where to find mounts */
  83. #ifdef VMS
  84. PRIVATE char *HTCacheRoot = "/WWW$SCRATCH";   /* Where to cache things */
  85. #else
  86. PRIVATE char *HTCacheRoot = "/tmp/W3_Cache_";   /* Where to cache things */
  87. #endif
  88.  
  89. /* PRIVATE char *HTSaveRoot  = "$(HOME)/WWW/";*/    /* Where to save things */
  90.  
  91.  
  92. /*    Suffix registration
  93. */
  94.  
  95. PRIVATE HTList * HTSuffixes = 0;
  96. PRIVATE HTSuffix no_suffix = { "*", NULL, NULL, 1.0 };
  97. PRIVATE HTSuffix unknown_suffix = { "*.*", NULL, NULL, 1.0};
  98.  
  99.  
  100. /*    Define the representation associated with a file suffix
  101. **    -------------------------------------------------------
  102. **
  103. **    Calling this with suffix set to "*" will set the default
  104. **    representation.
  105. **    Calling this with suffix set to "*.*" will set the default
  106. **    representation for unknown suffix files which contain a ".".
  107. **
  108. **    If filename suffix is already defined its previous
  109. **    definition is overridden.
  110. */
  111. PUBLIC void HTSetSuffix ARGS4(
  112.     CONST char *,    suffix,
  113.     CONST char *,    representation,
  114.     CONST char *,    encoding,
  115.     float,        value)
  116. {
  117.     
  118.     HTSuffix * suff;
  119.  
  120.     if (strcmp(suffix, "*")==0) suff = &no_suffix;
  121.     else if (strcmp(suffix, "*.*")==0) suff = &unknown_suffix;
  122.     else {
  123.     HTList *cur = HTSuffixes;
  124.  
  125.     while (NULL != (suff = (HTSuffix*)HTList_nextObject(cur))) {
  126.         if (suff->suffix && 0==strcmp(suff->suffix, suffix))
  127.         break;
  128.     }
  129.     if (!suff) { /* Not found -- create a new node */
  130.         suff = (HTSuffix*) calloc(1, sizeof(HTSuffix));
  131.         if (suff == NULL) outofmem(__FILE__, "HTSetSuffix");
  132.     
  133.         if (!HTSuffixes) HTSuffixes = HTList_new();
  134.         HTList_addObject(HTSuffixes, suff);
  135.     
  136.         StrAllocCopy(suff->suffix, suffix);
  137.     }
  138.     }
  139.  
  140.     suff->rep = HTAtom_for(representation);
  141.  
  142.     {
  143.         char * enc = NULL;
  144.     char * p;
  145.     StrAllocCopy(enc, encoding);
  146.     for (p=enc; *p; p++) *p = TOLOWER(*p);
  147.     suff->encoding = HTAtom_for(encoding);
  148.     }
  149.     
  150.     suff->quality = value;
  151. }
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158.  
  159. /*    Send README file
  160. **
  161. **  If a README file exists, then it is inserted into the document here.
  162. */
  163.  
  164. #ifdef GOT_READ_DIR
  165. PRIVATE void do_readme ARGS2(HTStructured *, target, CONST char *, localname)
  166. { 
  167.     FILE * fp;
  168.     char * readme_file_name = 
  169.     malloc(strlen(localname)+ 1 + strlen(HT_DIR_README_FILE) + 1);
  170.     strcpy(readme_file_name, localname);
  171.     strcat(readme_file_name, "/");
  172.     strcat(readme_file_name, HT_DIR_README_FILE);
  173.     
  174.     fp = fopen(readme_file_name,  "r");
  175.     
  176.     if (fp) {
  177.     HTStructuredClass targetClass;
  178.     
  179.     targetClass =  *target->isa;    /* (Can't init agregate in K&R) */
  180. #ifdef MSDOSMEM
  181.     {
  182.         extern void *vp_msdosmem;
  183.         extern void **vpp_msdosmem;
  184.         vp_msdosmem = NULL;
  185.         vpp_msdosmem = NULL;
  186.     }
  187. #endif /* MSDOSMEM */
  188.     START(HTML_PRE);
  189.     for(;;){
  190.         char c = fgetc(fp);
  191.         if (c == (char)EOF) break;
  192.         switch (c) {
  193.             case '&':
  194.         case '<':
  195.         case '>':
  196.             PUTC('&');
  197.             PUTC('#');
  198.             PUTC((char)(c / 10));
  199.             PUTC((char) (c % 10));
  200.             PUTC(';');
  201.             break;
  202. /*            case '\n':
  203.             PUTC('\r');    
  204. Bug removed thanks to joe@athena.mit.edu */            
  205.         default:
  206.             PUTC(c);
  207.         }
  208.     }
  209.     END(HTML_PRE);
  210.     fclose(fp);
  211.     } 
  212. }
  213. #endif
  214.  
  215.  
  216. /*    Make the cache file name for a W3 document
  217. **    ------------------------------------------
  218. **    Make up a suitable name for saving the node in
  219. **
  220. **    E.g.    /tmp/WWW_Cache_news/1234@cernvax.cern.ch
  221. **        /tmp/WWW_Cache_http/crnvmc/FIND/xx.xxx.xx
  222. **
  223. ** On exit,
  224. **    returns    a malloc'ed string which must be freed by the caller.
  225. */
  226. PUBLIC char * HTCacheFileName ARGS1(CONST char *,name)
  227. {
  228.     char * access = HTParse(name, "", PARSE_ACCESS);
  229.     char * host = HTParse(name, "", PARSE_HOST);
  230.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  231.     
  232.     char * result;
  233.     result = (char *)malloc(
  234.         strlen(HTCacheRoot)+strlen(access)
  235.         +strlen(host)+strlen(path)+6+1);
  236.     if (result == NULL) outofmem(__FILE__, "HTCacheFileName");
  237.     sprintf(result, "%s/WWW/%s/%s%s", HTCacheRoot, access, host, path);
  238.     free(path);
  239.     free(access);
  240.     free(host);
  241.     return result;
  242. }
  243.  
  244.  
  245. /*    Open a file for write, creating the path
  246. **    ----------------------------------------
  247. */
  248. #ifdef NOT_IMPLEMENTED
  249. PRIVATE int HTCreatePath ARGS1(CONST char *,path)
  250. {
  251.     return -1;
  252. }
  253. #endif
  254.  
  255. /*    Convert filenames between local and WWW formats
  256. **    -----------------------------------------------
  257. **    Make up a suitable name for saving the node in
  258. **
  259. **    E.g.    $(HOME)/WWW/news/1234@cernvax.cern.ch
  260. **        $(HOME)/WWW/http/crnvmc/FIND/xx.xxx.xx
  261. **
  262. ** On exit,
  263. **    returns    a malloc'ed string which must be freed by the caller.
  264. */
  265. PUBLIC char * HTLocalName ARGS1(CONST char *,name)
  266. {
  267.     char * access = HTParse(name, "", PARSE_ACCESS);
  268.     char * host = HTParse(name, "", PARSE_HOST);
  269.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  270.     
  271.     HTUnEscape(path);    /* Interpret % signs */
  272.     
  273.     if (0==strcmp(access, "file")) { /* local file */
  274.         free(access);    
  275.     if ((0==strcasecomp(host, HTHostName())) ||
  276.         (0==strcasecomp(host, "localhost")) || !*host) {
  277.         free(host);
  278. #ifndef RELEASE
  279.         if (TRACE) fprintf(stderr, "Node `%s' means path `%s'\n", name, path);
  280. #endif /* RELEASE */
  281. #ifdef MSDOS
  282.         {
  283.             /*
  284.              *    Convert the path to a dos file name.
  285.              */
  286.             extern void urltodos(char *);
  287.  
  288.             urltodos(path);
  289.         }
  290. #endif /* MSDOS */
  291.         return(path);
  292.     } else {
  293.         char * result = (char *)malloc(
  294.                     strlen("/Net/")+strlen(host)+strlen(path)+1);
  295.           if (result == NULL) outofmem(__FILE__, "HTLocalName");
  296.         sprintf(result, "%s%s%s", "/Net/", host, path);
  297.         free(host);
  298.         free(path);
  299. #ifndef RELEASE
  300.         if (TRACE) fprintf(stderr, "Node `%s' means file `%s'\n", name, result);
  301. #endif /* RELEASE */
  302.         return result;
  303.     }
  304.     } else {  /* other access */
  305.     char * result;
  306.         CONST char * home =  (CONST char*)getenv("HOME");
  307. #ifdef VMS
  308.     if (!home) 
  309.         home = HTCacheRoot; 
  310.     else
  311.            home = HTVMS_wwwName(home);
  312. #else /* not VMS */
  313.     if (!home) home = "/tmp"; 
  314. #endif /* not VMS */
  315.     result = (char *)malloc(
  316.         strlen(home)+strlen(access)+strlen(host)+strlen(path)+6+1);
  317.       if (result == NULL) outofmem(__FILE__, "HTLocalName");
  318.     sprintf(result, "%s/WWW/%s/%s%s", home, access, host, path);
  319.     free(path);
  320.     free(access);
  321.     free(host);
  322.     return result;
  323.     }
  324. }
  325.  
  326.  
  327. /*    Make a WWW name from a full local path name
  328. **
  329. ** Bugs:
  330. **    At present, only the names of two network root nodes are hand-coded
  331. **    in and valid for the NeXT only. This should be configurable in
  332. **    the general case.
  333. */
  334.  
  335. PUBLIC char * WWW_nameOfFile ARGS1 (CONST char *,name)
  336. {
  337.     char * result;
  338. #ifdef NeXT
  339.     if (0==strncmp("/private/Net/", name, 13)) {
  340.     result = (char *)malloc(7+strlen(name+13)+1);
  341.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  342.     sprintf(result, "file://%s", name+13);
  343.     } else
  344. #endif
  345.     if (0==strncmp(HTMountRoot, name, 5)) {
  346.     result = (char *)malloc(7+strlen(name+5)+1);
  347.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  348.     sprintf(result, "file://%s", name+5);
  349.     } else {
  350.         result = (char *)malloc(7+strlen(HTHostName())+strlen(name)+1);
  351.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  352.     sprintf(result, "file://%s%s", HTHostName(), name);
  353.     }
  354. #ifndef RELEASE
  355.     if (TRACE) fprintf(stderr, "File `%s'\n\tmeans node `%s'\n", name, result);
  356. #endif /* RELEASE */
  357.     return result;
  358. }
  359.  
  360.  
  361. /*    Determine a suitable suffix, given the representation
  362. **    -----------------------------------------------------
  363. **
  364. ** On entry,
  365. **    rep    is the atomized MIME style representation
  366. **
  367. ** On exit,
  368. **    returns    a pointer to a suitable suffix string if one has been
  369. **        found, else "".
  370. */
  371. PUBLIC CONST char * HTFileSuffix ARGS1(HTAtom*, rep)
  372. {
  373.     HTSuffix * suff;
  374.     int n;
  375.     int i;
  376.  
  377. #ifndef NO_INIT    
  378.     if (!HTSuffixes) HTFileInit();
  379. #endif
  380.     n = HTList_count(HTSuffixes);
  381.  
  382.     for(i=0; i<n; i++) {
  383.     suff = HTList_objectAt(HTSuffixes, i);
  384.  
  385.     if (suff->rep == rep) {
  386.         return((const char *)(suff->suffix));    /* OK -- found */
  387.     }
  388.     }
  389.  
  390.     return "";        /* Dunno */
  391. }
  392.  
  393.  
  394. /*    Determine file format from file name
  395. **    ------------------------------------
  396. **
  397. **    This version will return the representation and also set
  398. **    a variable for the encoding.
  399. **
  400. **    It will handle for example  x.txt, x.txt,Z, x.Z
  401. */
  402.  
  403. PUBLIC HTFormat HTFileFormat ARGS2 (
  404.             CONST char *,    filename,
  405.             HTAtom **,    pencoding)
  406.  
  407. {
  408.     HTSuffix * suff;
  409.     int n;
  410.     int i;
  411.     int lf = strlen(filename);
  412.  
  413. #ifndef NO_INIT    
  414.     if (!HTSuffixes) HTFileInit();
  415. #endif
  416.     *pencoding = NULL;
  417.     n = HTList_count(HTSuffixes);
  418.     for(i=0; i<n; i++) {
  419.         int ls;
  420.     suff = HTList_objectAt(HTSuffixes, i);
  421.     ls = strlen(suff->suffix);
  422.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  423.         int j;
  424.         *pencoding = suff->encoding;
  425.         if (suff->rep) return suff->rep;        /* OK -- found */
  426.         
  427.         for(j=0; j<n; j++) {  /* Got encoding, need representation */
  428.         int ls2;
  429.         suff = HTList_objectAt(HTSuffixes, j);
  430.         ls2 = strlen(suff->suffix);
  431.         if ((ls <= lf) && 0==strncmp(
  432.             suff->suffix, filename + lf - ls -ls2, ls2)) {
  433.             if (suff->rep) return suff->rep;
  434.         }
  435.         }
  436.         
  437.     }
  438.     }
  439.     
  440.     /* defaults tree */
  441.     
  442.     suff = strchr(filename, '.') ?     /* Unknown suffix */
  443.      ( unknown_suffix.rep ? &unknown_suffix : &no_suffix)
  444.      : &no_suffix;
  445.      
  446.     /* set default encoding unless found with suffix already */
  447.     if (!*pencoding) *pencoding = suff->encoding ? suff->encoding
  448.                     : HTAtom_for("binary");
  449.     return suff->rep ? suff->rep : WWW_BINARY;
  450. }
  451.  
  452.  
  453. /*    Determine value from file name
  454. **    ------------------------------
  455. **
  456. */
  457.  
  458. PUBLIC float HTFileValue ARGS1 (CONST char *,filename)
  459.  
  460. {
  461.     HTSuffix * suff;
  462.     int n;
  463.     int i;
  464.     int lf = strlen(filename);
  465.  
  466. #ifndef NO_INIT    
  467.     if (!HTSuffixes) HTFileInit();
  468. #endif
  469.     n = HTList_count(HTSuffixes);
  470.     for(i=0; i<n; i++) {
  471.         int ls;
  472.     suff = HTList_objectAt(HTSuffixes, i);
  473.     ls = strlen(suff->suffix);
  474.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  475. #ifndef RELEASE
  476.         if (TRACE) fprintf(stderr, "File: Value of %s is %.3f\n",
  477.                    filename, suff->quality);
  478. #endif /* RELEASE */
  479.         return suff->quality;        /* OK -- found */
  480.     }
  481.     }
  482.     return 0.3;        /* Dunno! */
  483. }
  484.  
  485.  
  486. /*    Determine write access to a file
  487. **    --------------------------------
  488. **
  489. ** On exit,
  490. **    return value    YES if file can be accessed and can be written to.
  491. **
  492. ** Bugs:
  493. **    1.    No code for non-unix systems.
  494. **    2.    Isn't there a quicker way?
  495. */
  496.  
  497. #ifdef VMS
  498. #define NO_GROUPS
  499. #endif
  500. #ifdef NO_UNIX_IO
  501. #define NO_GROUPS
  502. #endif
  503. #ifdef PCNFS
  504. #define NO_GROUPS
  505. #endif
  506. #ifdef MSDOS
  507. #define NO_GROUPS
  508. #endif
  509.  
  510. PUBLIC BOOL HTEditable ARGS1 (CONST char *,filename)
  511. {
  512. #ifdef NO_GROUPS
  513.     return NO;        /* Safe answer till we find the correct algorithm */
  514. #else
  515.     int     groups[NGROUPS];
  516.     uid_t    myUid;
  517.     int        ngroups;            /* The number of groups  */
  518.     struct stat    fileStatus;
  519.     int        i;
  520.  
  521.     if (stat(filename, &fileStatus))        /* Get details of filename */
  522.     return NO;                /* Can't even access file! */
  523.  
  524.     ngroups = getgroups(NGROUPS, groups);    /* Groups to which I belong  */
  525.     myUid = geteuid();                /* Get my user identifier */
  526.  
  527. #ifndef RELEASE
  528.     if (TRACE) {
  529.     int i;
  530.     fprintf(stderr,
  531.         "File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
  532.         (unsigned int) fileStatus.st_mode, fileStatus.st_uid,
  533.         fileStatus.st_gid,
  534.         myUid, ngroups);
  535.     for (i=0; i<ngroups; i++) fprintf(stderr, " %d", groups[i]);
  536.     fprintf(stderr, ")\n");
  537.     }
  538. #endif /* RELEASE */
  539.     
  540.     if (fileStatus.st_mode & 0002)        /* I can write anyway? */
  541.         return YES;
  542.     
  543.     if ((fileStatus.st_mode & 0200)        /* I can write my own file? */
  544.      && (fileStatus.st_uid == myUid))
  545.         return YES;
  546.  
  547.     if (fileStatus.st_mode & 0020)        /* Group I am in can write? */
  548.     {
  549.        for (i=0; i<ngroups; i++) {
  550.             if (groups[i] == fileStatus.st_gid)
  551.         return YES;
  552.     }
  553.     }
  554. #ifndef RELEASE
  555.     if (TRACE) fprintf(stderr, "\tFile is not editable.\n");
  556. #endif /* RELEASE */
  557.     return NO;                    /* If no excuse, can't do */
  558. #endif
  559. }
  560.  
  561.  
  562. /*    Make a save stream
  563. **    ------------------
  564. **
  565. **    The stream must be used for writing back the file.
  566. **    @@@ no backup done
  567. */
  568. PUBLIC HTStream * HTFileSaveStream ARGS1(HTParentAnchor *, anchor)
  569. {
  570.  
  571.     CONST char * addr = HTAnchor_address((HTAnchor*)anchor);
  572.     char *  localname = HTLocalName(addr);
  573.  
  574.     FILE* fp = fopen(localname, "w");
  575.     if (!fp) return NULL;
  576.     
  577.     return HTFWriter_new(fp);
  578.     
  579. }
  580.  
  581. /*      Output one directory entry
  582. **
  583. */
  584. PUBLIC void HTDirEntry ARGS3(HTStructured *, target,
  585.          CONST char * , tail,
  586.          CONST char *,  entry)
  587. {
  588.     char * relative;
  589.     char * escaped = HTEscape(entry, URL_XPALPHAS);
  590.  
  591.     /* If empty tail, gives absolute ref below */
  592.     relative = (char*) malloc(
  593.                   strlen(tail) + strlen(escaped)+2);
  594.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  595.     sprintf(relative, "%s/%s", tail, escaped);
  596.     HTStartAnchor(target, NULL, relative);
  597.     free(escaped);
  598.     free(relative);
  599. }
  600.  
  601. /*      Output parent directory entry
  602. **
  603. **    This gives the TITLE and H1 header, and also a link
  604. **    to the parent directory if appropriate.
  605. */
  606. PUBLIC void HTDirTitles ARGS2(HTStructured *, target,
  607.          HTAnchor * , anchor)
  608.  
  609. {
  610.     char * logical = HTAnchor_address(anchor);
  611.     char * path = HTParse(logical, "", PARSE_PATH + PARSE_PUNCTUATION);
  612.     char * current;
  613.  
  614.     current = strrchr(path, '/');    /* last part or "" */
  615.     free(logical);
  616.  
  617.     {
  618.       char * printable = NULL;
  619.       StrAllocCopy(printable, (current + 1));
  620.       HTUnEscape(printable);
  621. #ifdef MSDOSMEM
  622.     {
  623.         extern void *vp_msdosmem;
  624.         extern void **vpp_msdosmem;
  625.         vp_msdosmem = NULL;
  626.         vpp_msdosmem = NULL;
  627.     }
  628. #endif /* MSDOSMEM */
  629.       START(HTML_TITLE);
  630.       PUTS(*printable ? printable : "Welcome ");
  631.       PUTS(" directory");
  632.       END(HTML_TITLE);    
  633.     
  634. #ifdef MSDOSMEM
  635.     {
  636.         extern void *vp_msdosmem;
  637.         extern void **vpp_msdosmem;
  638.         vp_msdosmem = NULL;
  639.         vpp_msdosmem = NULL;
  640.     }
  641. #endif /* MSDOSMEM */
  642.       START(HTML_H1);
  643.       PUTS(*printable ? printable : "Welcome");
  644.       END(HTML_H1);
  645.       free(printable);
  646.     }
  647.  
  648.     /*  Make link back to parent directory
  649.      */
  650.  
  651.     if (current && current[1]) {   /* was a slash AND something else too */
  652.         char * parent;
  653.     char * relative;
  654.     *current++ = 0;
  655.       parent = strrchr(path, '/');  /* penultimate slash */
  656.  
  657.     relative = (char*) malloc(strlen(current) + 4);
  658.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  659.     sprintf(relative, "%s/..", current);
  660.     HTStartAnchor(target, "", relative);
  661.     free(relative);
  662.  
  663.     PUTS("Up to ");
  664.     if (parent) {
  665.       char * printable = NULL;
  666.       StrAllocCopy(printable, parent + 1);
  667.       HTUnEscape(printable);
  668.       PUTS(printable);
  669.       free(printable);
  670.     } else {
  671.       PUTS("/");
  672.     }
  673.  
  674.     END(HTML_A);
  675.  
  676.     }
  677.     free(path);
  678. }
  679.         
  680.  
  681.  
  682. /*    Load a document
  683. **    ---------------
  684. **
  685. ** On entry,
  686. **    addr        must point to the fully qualified hypertext reference.
  687. **            This is the physsical address of the file
  688. **
  689. ** On exit,
  690. **    returns        <0        Error has occured.
  691. **            HTLOADED    OK 
  692. **
  693. */
  694. PUBLIC int HTLoadFile ARGS4 (
  695.     CONST char *,        addr,
  696.     HTParentAnchor *,    anchor,
  697.     HTFormat,        format_out,
  698.     HTStream *,        sink
  699. )
  700. {
  701.     char * filename;
  702.     HTFormat format;
  703.     char * nodename = 0;
  704.     char * newname=0;    /* Simplified name of file */
  705.     HTAtom * encoding;    /* @@ not used yet */
  706.     
  707. /*    Reduce the filename to a basic form (hopefully unique!)
  708. */
  709.     StrAllocCopy(newname, addr);
  710.     filename=HTParse(newname, "", PARSE_PATH|PARSE_PUNCTUATION);
  711.     nodename=HTParse(newname, "", PARSE_HOST);
  712.     free(newname);
  713.     
  714.     format = HTFileFormat(filename, &encoding);
  715.  
  716.  
  717. #ifdef VMS
  718. /* Assume that the file is in Unix-style syntax if it contains a '/'
  719.    after the leading one @@ */
  720.     {
  721.         FILE * fp;
  722.     char * vmsname = strchr(filename + 1, '/') ?
  723.       HTVMS_name(nodename, filename) : filename + 1;
  724.     fp = fopen(vmsname, "r", "shr=put", "shr=upd");
  725.     
  726. /*    If the file wasn't VMS syntax, then perhaps it is ultrix
  727. */
  728.     if (!fp) {
  729.         char ultrixname[INFINITY];
  730. #ifndef RELEASE
  731.         if (TRACE) fprintf(stderr, "HTFile: Can't open as %s\n", vmsname);
  732. #endif /* RELEASE */
  733.         sprintf(ultrixname, "%s::\"%s\"", nodename, filename);
  734.           fp = fopen(ultrixname, "r", "shr=put", "shr=upd");
  735.         if (!fp) {
  736. #ifndef RELEASE
  737.         if (TRACE) fprintf(stderr,
  738.                    "HTFile: Can't open as %s\n", ultrixname);
  739. #endif /* RELEASE */
  740.         }
  741.     }
  742.         if (fp)
  743.         {
  744.         if (HTEditable(vmsname)) {
  745.         HTAtom * put = HTAtom_for("PUT");
  746.         HTList * methods = HTAnchor_methods(anchor);
  747.         if (HTList_indexOf(methods, put) == (-1)) {
  748.                HTList_addObject(methods, put);
  749.             }
  750.         }
  751.         HTParseFile(format, format_out, anchor, fp, sink);
  752.         fclose(fp);
  753.             return HT_LOADED;
  754.         }  /* If successfull open */
  755.     }
  756. #else
  757.  
  758.     free(filename);
  759.     
  760. /*    For unix, we try to translate the name into the name of a transparently
  761. **    mounted file.
  762. **
  763. **    Not allowed in secure (HTClienntHost) situations TBL 921019
  764. */
  765. #ifndef NO_UNIX_IO
  766.     /*  Need protection here for telnet server but not httpd server */
  767.      
  768.     if (!HTSecure) {        /* try local file system */
  769.     char * localname = HTLocalName(addr);
  770.     struct stat dir_info;
  771.     
  772. #ifdef GOT_READ_DIR
  773.  
  774. /*              Multiformat handling
  775. **
  776. **    If needed, scan directory to find a good file.
  777. **  Bug:  we don't stat the file to find the length
  778. */
  779.     if ( (strlen(localname) > strlen(MULTI_SUFFIX))
  780.        && (0==strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
  781.               MULTI_SUFFIX))) {
  782.         DIR *dp;
  783.  
  784.         STRUCT_DIRENT * dirbuf;
  785.         float best = NO_VALUE_FOUND;    /* So far best is bad */
  786.         HTFormat best_rep = NULL;    /* Set when rep found */
  787.         STRUCT_DIRENT best_dirbuf;    /* Best dir entry so far */
  788.  
  789.         char * base = strrchr(localname, '/');
  790.         int baselen;
  791.  
  792.         if (!base || base == localname) goto forget_multi;
  793.         *base++ = 0;        /* Just got directory name */
  794.         baselen = strlen(base)- strlen(MULTI_SUFFIX);
  795.         base[baselen] = 0;    /* Chop off suffix */
  796.  
  797.         dp = opendir(localname);
  798.         if (!dp) {
  799. forget_multi:
  800.         free(localname);
  801.         return HTLoadError(sink, 500,
  802.             "Multiformat: directory scan failed.");
  803.         }
  804.         
  805.         while ((dirbuf = readdir(dp))!=0) {
  806.             /* while there are directory entries to be read */
  807.         if (dirbuf->d_ino == 0) continue;
  808.                 /* if the entry is not being used, skip it */
  809.         
  810.         if (dirbuf->d_namlen > baselen &&      /* Match? */
  811.             !strncmp(dirbuf->d_name, base, baselen)) {    
  812.             HTFormat rep = HTFileFormat(dirbuf->d_name, &encoding);
  813.             float value = HTStackValue(rep, format_out,
  814.                             HTFileValue(dirbuf->d_name),
  815.                         0.0  /* @@@@@@ */);
  816.             if (value != NO_VALUE_FOUND) {
  817. #ifndef RELEASE
  818.             if (TRACE) fprintf(stderr,
  819.                 "HTFile: value of presenting %s is %f\n",
  820.                 HTAtom_name(rep), value);
  821. #endif /* RELEASE */
  822.             if  (value > best) {
  823.                 best_rep = rep;
  824.                 best = value;
  825.                 best_dirbuf = *dirbuf;
  826.                }
  827.             }    /* if best so far */             
  828.          } /* if match */  
  829.             
  830.         } /* end while directory entries left to read */
  831.         closedir(dp);
  832.         
  833.         if (best_rep) {
  834.         format = best_rep;
  835.         base[-1] = '/';        /* Restore directory name */
  836.         base[0] = 0;
  837.         StrAllocCat(localname, best_dirbuf.d_name);
  838.         goto open_file;
  839.         
  840.         } else {             /* If not found suitable file */
  841.         free(localname);
  842.         return HTLoadError(sink, 403,    /* List formats? */
  843.            "Could not find suitable representation for transmission.");
  844.         }
  845.         /*NOTREACHED*/
  846.     } /* if multi suffix */
  847. /*
  848. **    Check to see if the 'localname' is in fact a directory.  If it is
  849. **    create a new hypertext object containing a list of files and 
  850. **    subdirectories contained in the directory.  All of these are links
  851. **      to the directories or files listed.
  852. **      NB This assumes the existance of a type 'STRUCT_DIRENT', which will
  853. **      hold the directory entry, and a type 'DIR' which is used to point to
  854. **      the current directory being read.
  855. */
  856.     
  857.     
  858.     if (stat(localname,&dir_info) == -1) {     /* get file information */
  859.                                    /* if can't read file information */
  860. #ifndef RELEASE
  861.         if (TRACE) fprintf(stderr, "HTFile: can't stat %s\n", localname);
  862. #endif /* RELEASE */
  863.  
  864.     }  else {        /* Stat was OK */
  865.         
  866.  
  867.         if (((dir_info.st_mode) & S_IFMT) == S_IFDIR) {
  868.         /* if localname is a directory */    
  869.  
  870.         HTStructured* target;        /* HTML object */
  871.         HTStructuredClass targetClass;
  872.  
  873.         DIR *dp;
  874.         STRUCT_DIRENT * dirbuf;
  875.         
  876.         char * logical;
  877.         char * tail;
  878.         
  879.         BOOL present[HTML_A_ATTRIBUTES];
  880.         
  881.         char * tmpfilename = NULL;
  882.         struct stat file_info;
  883. #ifndef RELEASE
  884.         if (TRACE)
  885.             fprintf(stderr,"%s is a directory\n",localname);
  886. #endif /* RELEASE */
  887.             
  888. /*    Check directory access.
  889. **    Selective access means only those directories containing a
  890. **    marker file can be browsed
  891. */
  892.         if (HTDirAccess == HT_DIR_FORBID) {
  893.             free(localname);
  894.             return HTLoadError(sink, 403,
  895.             "Directory browsing is not allowed.");
  896.         }
  897.  
  898.  
  899.         if (HTDirAccess == HT_DIR_SELECTIVE) {
  900.             char * enable_file_name = 
  901.             malloc(strlen(localname)+ 1 +
  902.              strlen(HT_DIR_ENABLE_FILE) + 1);
  903.             strcpy(enable_file_name, localname);
  904.             strcat(enable_file_name, "/");
  905.             strcat(enable_file_name, HT_DIR_ENABLE_FILE);
  906.             if (stat(enable_file_name, &file_info) != 0) {
  907.             free(localname);
  908.             return HTLoadError(sink, 403,
  909.             "Selective access is not enabled for this directory");
  910.             }
  911.         }
  912.  
  913.  
  914.         dp = opendir(localname);
  915.         if (!dp) {
  916.             free(localname);
  917.             return HTLoadError(sink, 403, "This directory is not readable.");
  918.         }
  919.  
  920.  
  921.  /*    Directory access is allowed and possible
  922.  */
  923.         logical = HTAnchor_address((HTAnchor*)anchor);
  924.         tail = strrchr(logical, '/') +1;    /* last part or "" */
  925.         
  926.         target = HTML_new(anchor, format_out, sink);
  927.         targetClass = *target->isa;    /* Copy routine entry points */
  928.             
  929.           { int i;
  930.             for(i=0; i<HTML_A_ATTRIBUTES; i++)
  931.                 present[i] = (i==HTML_A_HREF);
  932.         }
  933.         
  934.                 HTDirTitles(target, (HTAnchor *)anchor);
  935.  
  936.         if (HTDirReadme == HT_DIR_README_TOP)
  937.             do_readme(target, localname);
  938.         {
  939.             HTBTree * bt = HTBTree_new((HTComparer)strcasecomp);
  940.  
  941.             while ((dirbuf = readdir(dp))!=0)
  942.             {
  943.                 HTBTElement * dirname = NULL;
  944.  
  945.                 /* while there are directory entries to be read */
  946.                 if (dirbuf->d_ino == 0)
  947.                   /* if the entry is not being used, skip it */
  948.                 continue;
  949.             
  950.  
  951.                 /* if the current entry is parent directory */
  952.             if ((*(dirbuf->d_name)=='.') ||
  953.                 (*(dirbuf->d_name)==','))
  954.                 continue;    /* skip those files whose name begins
  955.                         with '.' or ',' */
  956.  
  957.             dirname = (HTBTElement *)malloc(
  958.                     strlen(dirbuf->d_name) + 2);
  959.             if (dirname == NULL) outofmem(__FILE__,"DirRead");
  960.             StrAllocCopy(tmpfilename,localname);
  961.             if (strcmp(localname,"/"))
  962.  
  963.                     /* if filename is not root directory */
  964.                 StrAllocCat(tmpfilename,"/"); 
  965.  
  966.  
  967.             StrAllocCat(tmpfilename,dirbuf->d_name);
  968.             stat(tmpfilename, &file_info);
  969.             if (((file_info.st_mode) & S_IFMT) == S_IFDIR)
  970.                 sprintf((char *)dirname,"D%s",dirbuf->d_name);
  971.             else sprintf((char *)dirname,"F%s",dirbuf->d_name);
  972.                 /* D & F to have first directories, then files */
  973.             HTBTree_add(bt,dirname); /* Sort dirname in the tree bt */
  974.             }
  975.  
  976.             /*    Run through tree printing out in order
  977.              */
  978.             {
  979.                 HTBTElement * next_element = HTBTree_next(bt,NULL);
  980.                 /* pick up the first element of the list */
  981.             char state;
  982.                 /* I for initial (.. file),
  983.                    D for directory file,
  984.                    F for file */
  985.             
  986.             state = 'I';
  987.  
  988.             while (next_element != NULL)
  989.                 {
  990.                 StrAllocCopy(tmpfilename,localname);
  991.                 if (strcmp(localname,"/")) 
  992.  
  993.                     /* if filename is not root directory */
  994.                     StrAllocCat(tmpfilename,"/"); 
  995.  
  996.                 StrAllocCat(tmpfilename,
  997.                     (char *)HTBTree_object(next_element)+1);
  998.                 /* append the current entry's filename to the path */
  999.                 HTSimplify(tmpfilename);
  1000.                 /* Output the directory entry */
  1001.                 if (strcmp((char *)
  1002.                          (HTBTree_object(next_element)),"D.."))
  1003.                 {                
  1004.                 if (state != *(char *)(HTBTree_object(next_element)))
  1005.                 {
  1006.                     if (state == 'D')
  1007.                         END(HTML_DIR);
  1008.                     state = *(char *)
  1009.                         (HTBTree_object(next_element))=='D'?'D':'F';
  1010. #ifdef MSDOSMEM
  1011.     {
  1012.         extern void *vp_msdosmem;
  1013.         extern void **vpp_msdosmem;
  1014.         vp_msdosmem = NULL;
  1015.         vpp_msdosmem = NULL;
  1016.     }
  1017. #endif /* MSDOSMEM */
  1018.                     START(HTML_H2);
  1019.                     PUTS(state == 'D'?"Subdirectories:":"Files");
  1020.                     END(HTML_H2);
  1021. #ifdef MSDOSMEM
  1022.     {
  1023.         extern void *vp_msdosmem;
  1024.         extern void **vpp_msdosmem;
  1025.         vp_msdosmem = NULL;
  1026.         vpp_msdosmem = NULL;
  1027.     }
  1028. #endif /* MSDOSMEM */
  1029.                     START(HTML_DIR);
  1030.                 }
  1031. #ifdef MSDOSMEM
  1032.     {
  1033.         extern void *vp_msdosmem;
  1034.         extern void **vpp_msdosmem;
  1035.         vp_msdosmem = NULL;
  1036.         vpp_msdosmem = NULL;
  1037.     }
  1038. #endif /* MSDOSMEM */
  1039.                 START(HTML_LI);
  1040.                 }
  1041.                 HTDirEntry(target, tail,
  1042.                        (char*)HTBTree_object(next_element) +1);
  1043.                 PUTS(entry);
  1044.                 END(HTML_A);
  1045.  
  1046.                 next_element = HTBTree_next(bt,next_element);
  1047.                     /* pick up the next element of the list; 
  1048.                  if none, return NULL*/
  1049.             }
  1050.             if (state == 'I')
  1051.             {
  1052. #ifdef MSDOSMEM
  1053.     {
  1054.         extern void *vp_msdosmem;
  1055.         extern void **vpp_msdosmem;
  1056.         vp_msdosmem = NULL;
  1057.         vpp_msdosmem = NULL;
  1058.     }
  1059. #endif /* MSDOSMEM */
  1060.                 START(HTML_P);
  1061.                 PUTS("Empty Directory");
  1062.             }
  1063.             else
  1064.                 END(HTML_DIR);
  1065.             }
  1066.  
  1067.                 /* end while directory entries left to read */
  1068.             closedir(dp);
  1069.             free(logical);
  1070.             free(tmpfilename);
  1071.             HTBTreeAndObject_free(bt);
  1072.  
  1073.             if (HTDirReadme == HT_DIR_README_BOTTOM)
  1074.               do_readme(target, localname);
  1075.             FREE_TARGET;
  1076.             free(localname);
  1077.             return HT_LOADED;    /* document loaded */
  1078.         }
  1079.  
  1080.         } /* end if localname is directory */
  1081.     
  1082.     } /* end if file stat worked */
  1083.     
  1084. /* End of directory reading section
  1085. */
  1086. #endif
  1087. open_file:
  1088.     {
  1089.         FILE * fp = fopen(localname,"r");
  1090. #ifndef RELEASE
  1091.         if(TRACE) fprintf (stderr, "HTFile: Opening `%s' gives %p\n",
  1092.                 localname, (void*)fp);
  1093. #endif /* RELEASE */
  1094.         if (fp) {        /* Good! */
  1095.         if (HTEditable(localname)) {
  1096.             HTAtom * put = HTAtom_for("PUT");
  1097.             HTList * methods = HTAnchor_methods(anchor);
  1098.             if (HTList_indexOf(methods, put) == (-1)) {
  1099.             HTList_addObject(methods, put);
  1100.             }
  1101.         }
  1102.         free(localname);
  1103.         HTParseFile(format, format_out, anchor, fp, sink);
  1104.         fclose(fp);
  1105.         return HT_LOADED;
  1106.         }  /* If succesfull open */
  1107.     }    /* scope of fp */
  1108.     }  /* local unix file system */    
  1109. #endif
  1110. #endif
  1111.  
  1112. #ifndef DECNET
  1113. /*    Now, as transparently mounted access has failed, we try FTP.
  1114. */
  1115.     {
  1116.     if (strcmp(nodename, HTHostName())!=0)
  1117.         return HTFTPLoad(addr, anchor, format_out, sink);
  1118.     }
  1119. #endif
  1120.  
  1121. /*    All attempts have failed.
  1122. */
  1123.     {
  1124. #ifndef RELEASE
  1125.     if (TRACE)
  1126.         printf("Can't open `%s', errno=%d\n", addr, errno);
  1127. #endif /* RELEASE */
  1128.  
  1129.     return HTLoadError(sink, 403, "Can't access requested file.");
  1130.     }
  1131.     
  1132.  
  1133. }
  1134.  
  1135. /*        Protocol descriptors
  1136. */
  1137. GLOBALDEF PUBLIC HTProtocol HTFTP  = { "ftp", HTLoadFile, 0 };
  1138. GLOBALDEF PUBLIC HTProtocol HTFile = { "file", HTLoadFile, HTFileSaveStream };